{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=5\n",
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True\n",
    "#equation_component_combination = [1.0,2.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Noise 20%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1] + np.random.normal(loc=0.0, scale=0.2, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.16882 | domain_loss:  557.84418 | bdc_loss:    0.59634\n",
      "epoch:  200.00000 | total_loss:    0.91532 | domain_loss:   38.97736 | bdc_loss:    0.53086\n",
      "epoch:  400.00000 | total_loss:    0.55900 | domain_loss:    8.76686 | bdc_loss:    0.47609\n",
      "epoch:  600.00000 | total_loss:    0.45627 | domain_loss:    3.48988 | bdc_loss:    0.42563\n",
      "epoch:  800.00000 | total_loss:    0.39256 | domain_loss:    1.89844 | bdc_loss:    0.37735\n",
      "epoch: 1000.00000 | total_loss:    0.34098 | domain_loss:    1.20891 | bdc_loss:    0.33221\n",
      "epoch: 1200.00000 | total_loss:    0.29882 | domain_loss:    0.81470 | bdc_loss:    0.29360\n",
      "epoch: 1400.00000 | total_loss:    0.26815 | domain_loss:    0.55521 | bdc_loss:    0.26525\n",
      "epoch: 1600.00000 | total_loss:    0.24953 | domain_loss:    0.38587 | bdc_loss:    0.24816\n",
      "epoch: 1800.00000 | total_loss:    0.24007 | domain_loss:    0.28294 | bdc_loss:    0.23964\n",
      "epoch: 2000.00000 | total_loss:    0.23547 | domain_loss:    0.22380 | bdc_loss:    0.23559\n",
      "epoch: 2200.00000 | total_loss:    0.23269 | domain_loss:    0.19228 | bdc_loss:    0.23310\n",
      "epoch: 2400.00000 | total_loss:    0.23038 | domain_loss:    0.17918 | bdc_loss:    0.23090\n",
      "epoch: 2600.00000 | total_loss:    0.22808 | domain_loss:    0.17937 | bdc_loss:    0.22857\n",
      "epoch: 2800.00000 | total_loss:    0.22563 | domain_loss:    0.18998 | bdc_loss:    0.22599\n",
      "epoch: 3000.00000 | total_loss:    0.22295 | domain_loss:    0.20964 | bdc_loss:    0.22308\n",
      "epoch: 3200.00000 | total_loss:    0.21996 | domain_loss:    0.23809 | bdc_loss:    0.21977\n",
      "epoch: 3400.00000 | total_loss:    0.21657 | domain_loss:    0.27597 | bdc_loss:    0.21597\n",
      "epoch: 3600.00000 | total_loss:    0.21270 | domain_loss:    0.32469 | bdc_loss:    0.21157\n",
      "epoch: 3800.00000 | total_loss:    0.20822 | domain_loss:    0.38626 | bdc_loss:    0.20642\n",
      "epoch: 4000.00000 | total_loss:    0.20301 | domain_loss:    0.46322 | bdc_loss:    0.20038\n",
      "epoch: 4200.00000 | total_loss:    0.19690 | domain_loss:    0.55817 | bdc_loss:    0.19325\n",
      "epoch: 4400.00000 | total_loss:    0.18976 | domain_loss:    0.67310 | bdc_loss:    0.18488\n",
      "epoch: 4600.00000 | total_loss:    0.18146 | domain_loss:    0.80795 | bdc_loss:    0.17513\n",
      "epoch: 4800.00000 | total_loss:    0.17195 | domain_loss:    0.95864 | bdc_loss:    0.16401\n",
      "epoch: 5000.00000 | total_loss:    0.16131 | domain_loss:    1.11510 | bdc_loss:    0.15168\n",
      "epoch: 5200.00000 | total_loss:    0.14980 | domain_loss:    1.26106 | bdc_loss:    0.13858\n",
      "epoch: 5400.00000 | total_loss:    0.13788 | domain_loss:    1.37720 | bdc_loss:    0.12536\n",
      "epoch: 5600.00000 | total_loss:    0.12623 | domain_loss:    1.44821 | bdc_loss:    0.11287\n",
      "epoch: 5800.00000 | total_loss:    0.11560 | domain_loss:    1.47045 | bdc_loss:    0.10192\n",
      "epoch: 6000.00000 | total_loss:    0.10666 | domain_loss:    1.45451 | bdc_loss:    0.09304\n",
      "epoch: 6200.00000 | total_loss:    0.09970 | domain_loss:    1.41930 | bdc_loss:    0.08637\n",
      "epoch: 6400.00000 | total_loss:    0.09461 | domain_loss:    1.38213 | bdc_loss:    0.08161\n",
      "epoch: 6600.00000 | total_loss:    0.09100 | domain_loss:    1.35267 | bdc_loss:    0.07825\n",
      "epoch: 6800.00000 | total_loss:    0.08837 | domain_loss:    1.33347 | bdc_loss:    0.07580\n",
      "epoch: 7000.00000 | total_loss:    0.08635 | domain_loss:    1.32354 | bdc_loss:    0.07386\n",
      "epoch: 7200.00000 | total_loss:    0.08466 | domain_loss:    1.32132 | bdc_loss:    0.07217\n",
      "epoch: 7400.00000 | total_loss:    0.08312 | domain_loss:    1.32570 | bdc_loss:    0.07056\n",
      "epoch: 7600.00000 | total_loss:    0.08160 | domain_loss:    1.33606 | bdc_loss:    0.06893\n",
      "epoch: 7800.00000 | total_loss:    0.08004 | domain_loss:    1.35186 | bdc_loss:    0.06719\n",
      "epoch: 8000.00000 | total_loss:    0.07834 | domain_loss:    1.37230 | bdc_loss:    0.06527\n",
      "epoch: 8200.00000 | total_loss:    0.07643 | domain_loss:    1.39596 | bdc_loss:    0.06310\n",
      "epoch: 8400.00000 | total_loss:    0.07423 | domain_loss:    1.42033 | bdc_loss:    0.06064\n",
      "epoch: 8600.00000 | total_loss:    0.07165 | domain_loss:    1.44120 | bdc_loss:    0.05782\n",
      "epoch: 8800.00000 | total_loss:    0.06859 | domain_loss:    1.45171 | bdc_loss:    0.05462\n",
      "epoch: 9000.00000 | total_loss:    0.06496 | domain_loss:    1.44164 | bdc_loss:    0.05105\n",
      "epoch: 9200.00000 | total_loss:    0.06070 | domain_loss:    1.39748 | bdc_loss:    0.04720\n",
      "epoch: 9400.00000 | total_loss:    0.05581 | domain_loss:    1.30486 | bdc_loss:    0.04320\n",
      "epoch: 9600.00000 | total_loss:    0.05041 | domain_loss:    1.15444 | bdc_loss:    0.03926\n",
      "epoch: 9800.00000 | total_loss:    0.04469 | domain_loss:    0.95033 | bdc_loss:    0.03554\n",
      "epoch: 10000.00000 | total_loss:    0.03884 | domain_loss:    0.71466 | bdc_loss:    0.03201\n",
      "epoch: 10200.00000 | total_loss:    0.03270 | domain_loss:    0.47935 | bdc_loss:    0.02818\n",
      "epoch: 10400.00000 | total_loss:    0.02430 | domain_loss:    0.23533 | bdc_loss:    0.02216\n",
      "epoch: 10600.00000 | total_loss:    0.01199 | domain_loss:    0.00000 | bdc_loss:    0.01211\n",
      "epoch: 10800.00000 | total_loss:    0.00798 | domain_loss:    0.00000 | bdc_loss:    0.00806\n",
      "epoch: 11000.00000 | total_loss:    0.00587 | domain_loss:    0.00000 | bdc_loss:    0.00593\n",
      "epoch: 11200.00000 | total_loss:    0.00447 | domain_loss:    0.00000 | bdc_loss:    0.00451\n",
      "epoch: 11400.00000 | total_loss:    0.00341 | domain_loss:    0.00000 | bdc_loss:    0.00345\n",
      "epoch: 11600.00000 | total_loss:    0.00258 | domain_loss:    0.00000 | bdc_loss:    0.00261\n",
      "epoch: 11800.00000 | total_loss:    0.00192 | domain_loss:    0.00000 | bdc_loss:    0.00194\n",
      "epoch: 12000.00000 | total_loss:    0.00140 | domain_loss:    0.00000 | bdc_loss:    0.00142\n",
      "epoch: 12200.00000 | total_loss:    0.00101 | domain_loss:    0.00000 | bdc_loss:    0.00102\n",
      "epoch: 12400.00000 | total_loss:    0.00071 | domain_loss:    0.00000 | bdc_loss:    0.00072\n",
      "epoch: 12600.00000 | total_loss:    0.00050 | domain_loss:    0.00000 | bdc_loss:    0.00050\n",
      "epoch: 12800.00000 | total_loss:    0.00034 | domain_loss:    0.00000 | bdc_loss:    0.00035\n",
      "epoch: 13000.00000 | total_loss:    0.00023 | domain_loss:    0.00000 | bdc_loss:    0.00023\n",
      "epoch: 13200.00000 | total_loss:    0.00015 | domain_loss:    0.00001 | bdc_loss:    0.00016\n",
      "epoch: 13400.00000 | total_loss:    0.00010 | domain_loss:    0.00000 | bdc_loss:    0.00010\n",
      "epoch: 13600.00000 | total_loss:    0.00006 | domain_loss:    0.00000 | bdc_loss:    0.00006\n",
      "epoch: 13800.00000 | total_loss:    0.00004 | domain_loss:    0.00000 | bdc_loss:    0.00004\n",
      "epoch: 14000.00000 | total_loss:    0.00002 | domain_loss:    0.00000 | bdc_loss:    0.00002\n",
      "epoch: 14200.00000 | total_loss:    0.00001 | domain_loss:    0.00000 | bdc_loss:    0.00001\n",
      "epoch: 14400.00000 | total_loss:    0.00001 | domain_loss:    0.00000 | bdc_loss:    0.00001\n",
      "epoch: 14600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 14800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16000.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 16200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_7/kernel:0' shape=(1, 1, 2, 1) dtype=float32, numpy=\n",
       " array([[[[7.1969347e-11],\n",
       "          [7.2791544e-11]]]], dtype=float32)>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99776625"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.19955325*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0),\n",
    "                     'k1':pde_model_train.layers[-6].weights[0][0,0,0,0].numpy(),\n",
    "                     'k2':pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.196935e-11"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.2791544e-11"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0114243"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-79.77151393890381"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
